oracle.pg.hbase

## Class OraclePropertyGraph

- java.lang.Object
- - oracle.pg.common.OraclePropertyGraphBase
  - - oracle.pg.hbase.OraclePropertyGraph

- All Implemented Interfaces:
    Graph, IndexableGraph, KeyIndexableGraph, TransactionalGraph

      public class OraclePropertyGraph
      extends OraclePropertyGraphBase

  This class implements the Blueprints Graph interface on top an Apache HBase backend database. Note that this implementation is not thread safe. To safely perform concurrent operations against a single graph, multiple instances of OraclePropertyGraph are recommended.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class oracle.pg.common.OraclePropertyGraphBase

      `OraclePropertyGraphBase.OptimizationFlag`

    - ### Nested classes/interfaces inherited from interface com.tinkerpop.blueprints.TransactionalGraph

      `TransactionalGraph.Conclusion`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addAttributeToAllEdges(EdgeOpCallback eoc)` Adds an attribute to all edges based on the specified EdgeOpCallback.
    `void` | `addAttributeToAllEdges(EdgeOpCallback eoc, boolean skipStoreToCache, int dop)` Adds an attribute to all edges based on the specified EdgeOpCallback.
    `void` | `addAttributeToAllEdges(EdgeOpCallback eoc, boolean skipStoreToCache, int dop, ProgressListener pl)` Adds an attribute to all edges based on the specified EdgeOpCallback.
    `void` | `addAttributeToAllVertices(VertexOpCallback voc)` Adds an attribute to all vertices based on the specified VertexOpCallback.
    `void` | `addAttributeToAllVertices(VertexOpCallback voc, boolean skipStoreToCache, int dop)` Adds an attribute to all vertices based on the specified VertexOpCallback.
    `void` | `addAttributeToAllVertices(VertexOpCallback voc, boolean skipStoreToCache, int dop, ProgressListener pl)` Adds an attribute to all vertices based on the specified VertexOpCallback.
    `Edge` | `addEdge(Object id, Vertex outVertex, Vertex inVertex, String label)` This method adds an edge to the graph instance.
    `Vertex` | `addVertex(Object id)` This method adds a vertex to the graph instance.
    `void` | `clearCache()` This method clear the Vertex and Edge caches associated to this property graph instance.
    `void` | `clearRepository()` This method removes all vertices and edges from this property graph instance.
    `void` | `commit()` Commit changes done to this property graph instace.
    `static byte[]` | `concatenate(byte[] ba1, byte[] ba2)` This method returns a byte array that concatenates the two given byte array If one of the argument is null, the return value will be the other argument.
    `static byte[]` | `concatenate(byte[] ba1, byte[] ba2, byte[] ba3)` This method returns a byte array that concatenates the two given byte array If one of the argument is null, the return value will be the other argument.
    `long` | `countEdges()` Counts all Edges
    `long` | `countEdges(int dop)` Counts all Edges using parallel scans and the specified DOP
    `long` | `countEdges(int dop, ProgressListener pl)` Counts all Edges using parallel scan and the specified DOP.
    `long` | `countEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, int startSplitID, ProgressListener pl)` The splits are determined by # of regions & m_iNumSplitsPerRegion.
    `long` | `countVertices()` Counts all vertices
    `long` | `countVertices(int dop)` Counts all vertices using parallel scans and the specified DOP.
    `long` | `countVertices(int dop, ProgressListener pl)` Counts all vertices using parallel scans and the specified DOP.
    `long` | `countVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, int startSplitID, ProgressListener pl)` The splits are determined by # of regions & m_iNumSplitsPerRegion.
    `<T extends Element> Index<T>` | `createIndex(String indexName, Class<T> indexClass, Parameter... indexParameters)` Generates an index with a particular name, for a particular class, and of a particular type.
    `<T extends Element> void` | `createKeyIndex(String[] keys, Class<T> elementClass)` Creates an automatically maintained index for the given keys and element class.
    `<T extends Element> void` | `createKeyIndex(String key, Class<T> elementClass, Parameter... parameters)` Creates an automatic indexing structure for indexing provided key for element class.
    `void` | `dropAllAutoIndices()` Drops all existing automatic indices (vertex and edges)
    `void` | `dropAllIndices()` Drops all existing indices
    `void` | `dropAllManualIndices()` Drops all existing manual indices (vertices and edges)
    `void` | `dropIndex(String indexName)` Removes an index associated with the graph.
    `void` | `dropIndexTable()` This method removes all indices meta data from this property graph instance.
    `<T extends Element> void` | `dropKeyIndex(String[] keys, Class<T> elementClass)` Removes an automatic indexing structure associated with indexing provided key for element class.
    `<T extends Element> void` | `dropKeyIndex(String key, Class<T> elementClass)` Removes an automatic indexing structure associated with indexing provided key for element class.
    `void` | `flushHbaseCommits()` Flush HBase tables so property grpah changes are commited into HBase.
    `<T extends Element> Index<T>` | `getAutoIndex(Class<T> indexClass)` Gets an index from the graph by its name and index class.
    `int` | `getBatchSize()` Get the size of the batch used for update operations.
    `String` | `getCompression()` Get the type of compression used in the property graph tables
    `org.apache.hadoop.hbase.io.compress.Compression.Algorithm` | `getCompressionAlgorithm(String compress)` An utility to get a Compression Algorithm based on the specified string
    `org.apache.hadoop.conf.Configuration` | `getConfiguration()` This method returns the underlying Configuration instance used for HBase
    `org.apache.hadoop.hbase.io.encoding.DataBlockEncoding` | `getDataBlockEncoding()` Gets the data block encoding algorithm used in block cache and optionally on disk for all property graph tables
    `OraclePropertyGraphBase.OptimizationFlag` | `getDefaultEdgeOptFlag()` Get the OptimizationFlag for edges associated to this property graph
    `OracleIndexParameters` | `getDefaultIndexParameters()` Get the default index parameters associated to this property graph.
    `OraclePropertyGraphBase.OptimizationFlag` | `getDefaultVertexOptFlag()` Get the OptimizationFlag for vertices associated to this property graph
    `OracleEdge` | `getEdge(Object id)` Return the edge referenced by the object identifier.
    `int` | `getEdgeBlockCacheSize()` Gets the size of the block cache (in bytes) associated to the edge table
    `EdgeFilterCallback` | `getEdgeFilterCallback()` Get the EdgeFilterCallback associated to this property graph
    `int` | `getEdgeInitialNumRegions()` Get the initial number of regions defined for the HBase Edge tables associated to this property graph.
    `OracleEdgeBase` | `getEdgeInstance(Long eid, boolean bCreateIfAbsentFromCache, boolean bSkipStoreToCache)` Returns an instance of OracleEdgeBase.
    `OracleEdgeBase` | `getEdgeInstance(OracleVertexBase outVertex, OracleVertexBase inVertex, String edgeLabel, Long eid, boolean bCreateIfAbsentFromCache, boolean bSkipStoreToCache)` Returns an instance of OracleEdge
    `int` | `getEdgePropertyNames(int dop, int timeout, Set<String> propertyNames)` Gets the property names of all edges.
    `int` | `getEdgePropertyNames(int dop, int timeout, Set<String> propertyNames, ProgressListener pl)` Gets the property names of all edges using parallel scans and the specified DOP.
    `void` | `getEdgePropertyNamesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, Set<String> propertyNames, long lStartTime, long lDeadline, int startSplitID, ProgressListener pl)` The splits are determined by # of regions & m_iNumSplitsPerRegion.
    `Iterable<Edge>` | `getEdges()` Return an Iterable to all the edges in the graph.
    `Iterable<Edge>` | `getEdges(String key)` Return an iterable to all the edges in the graph that have a particular key.
    `Iterable<Edge>` | `getEdges(String[] keys)` Return an iterable to all the edges in the graph that have any of the specified keys.
    `Iterable<Edge>` | `getEdges(String[] keys, EdgeFilterCallback efc)` Return an iterable to all the edges in the graph that have any of the specified keys and satisfy the specifed edge filter callback.
    `Iterable<Edge>` | `getEdges(String[] keys, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Return an iterable to all the edges in the graph that have any of the specified keys and satisfy the specifed edge filter callback.
    `Iterable<Edge>` | `getEdges(String key, Object value)` Return an iterable to all matching edges that have a particular key/value property.
    `Iterable<Edge>` | `getEdges(String key, Object value, boolean useWildCard)` Return an iterable to all matching edges that have a particular key/value property.
    `Iterable<Edge>` | `getEdges(String key, Object value, boolean acceptWildcard, boolean preferredLuceneQuery)` Return an iterable to all the vertices in the graph that have a particular key/value property.
    `Iterable<Edge>` | `getEdges(String key, Object value, Class dtClass, boolean acceptWildcard)` Return an iterable to all matching edges that have a particular key/value property.
    `Iterable<Edge>` | `getEdges(String key, Object value, Class dtClass, boolean acceptWildcard, boolean preferredLuceneQuery)` Return an iterable to all the vertices in the graph that have a particular key/value property.
    `Iterable<Edge>[]` | `getEdgesFromKey(org.apache.hadoop.hbase.client.HConnection[] conns, boolean skipStoreToCache, int startSplitID, String[] keys)` Return an iterable to all the edges in the graph that have a particular key/value property.
    `int` | `getEdgeSndIndexBlockCacheSize()` Gets the size of the block cache (in bytes) associated to the secondary index edge table
    `String` | `getEdgeSndIndexTabName()` Get the name of the HBase table used to store secondary indexes on edges in this property graph.
    `long` | `getEdgeSndIndexWriteBufferSize()` Set the write buffer size associated to the edge secondary index table
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, boolean bClonedGraph)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, EdgeFilterCallback efc)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, OraclePropertyGraphBase.OptimizationFlag flag)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String key)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String[] keys)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String[] keys, boolean bClonedGraph, EdgeFilterCallback efc)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String[] keys, boolean bClonedGraph, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `Iterable<Edge>[]` | `getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String key, boolean bClonedGraph)` Gets an array of `Iterable` objects that hold all the edges in the graph.
    `int` | `getEdgeTableSplits()` Get the number of Edge table splits based on the current number of splits per region associated to this graph and the number of regions in the edge table.
    `String` | `getEdgeTabName()` Get the name of the HBase table used to store edges in this property graph.
    `long` | `getEdgeWriteBufferSize()` Set the write buffer size associated to the edge table
    `Features` | `getFeatures()` Get the particular features of the graph implementation.
    `String` | `getGraphName()` This method returns the name of this property graph instance
    `<T extends Element> Index<T>` | `getIndex(String indexName, Class<T> indexClass)` Gets a manual index from the graph by its name and index class.
    `<T extends Element> Set<String>` | `getIndexedKeys(Class<T> elementClass)` Returns all the index keys associated with a particular element class.
    `<T extends Element> OracleIndexParameters` | `getIndexParameters(String indexName, Class<T> indexClass)` Get the index parameters associated to this property graph.
    `Iterable<Index<? extends Element>>` | `getIndices()` Gets all the indices maintained by the graph.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, int initialNumRegions)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, int initialNumRegions, int splitsPerRegion)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, int initialNumRegions, int splitsPerRegion, int blockCacheSize)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, String compress, org.apache.hadoop.hbase.io.encoding.DataBlockEncoding dbe, int splitsPerRegion, int blockCacheSize, int initialVertexNumRegions, int initialEdgeNumRegions)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, String compress, int initialNumRegions)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, String compress, int initialNumRegions, int splitsPerRegion)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, String compress, int initialNumRegions, int splitsPerRegion, int blockCacheSize)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, String compress, int splitsPerRegion, int blockCacheSize, int initialVertexNumRegions, int initialEdgeNumRegions)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    `static OraclePropertyGraph` | `getInstance(oracle.pgx.config.PgHbaseGraphConfig config)` Returns an instance of OraclePropertyGraph using a PGX PgHbaseGraphConfig object.
    `static OraclePropertyGraph` | `getInstanceWithSplits(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.hbase.client.HConnection hconn, String szGraphName, int splitsPerRegion)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided and the specified number of splits per region.
    `int` | `getLuceneBlockCacheSize()` Gets the size of the block cache (in bytes) associated to the Lucene index table
    `String` | `getLuceneTabName()` Get the name of the HBase table used to store index metadata in this property graph.
    `long` | `getLuceneWriteBufferSize()` Set the write buffer size associated to the Lucene index table
    `long` | `getMaxEdgeID()` Get max edge ID
    `long` | `getMaxEdgeID(int dop)` Get max edge ID using parallel scans and the specified DOP.
    `long` | `getMaxEdgeID(int dop, ProgressListener pl)` Get the maximal edge ID using parallel scan and the specified DOP.
    `long` | `getMaxVertexID()` Get min Vertex ID
    `long` | `getMaxVertexID(int dop)` Get min vertex ID using parallel scans and the specified DOP.
    `long` | `getMaxVertexID(int dop, ProgressListener pl)` Get min vertex ID using parallel scans and the specified DOP.
    `long` | `getMinEdgeID()` Get min edge ID
    `long` | `getMinEdgeID(int dop)` Get min edge ID using parallel scans and the specified DOP.
    `long` | `getMinEdgeID(int dop, ProgressListener pl)` Get the minimum edge ID using parallel scan and the specified DOP.
    `long` | `getMinVertexID()` Get min Vertex ID
    `long` | `getMinVertexID(int dop)` Get min vertex ID using parallel scans and the specified DOP.
    `long` | `getMinVertexID(int dop, ProgressListener pl)` Get min vertex ID using parallel scans and the specified DOP.
    `int` | `getNumSplitsPerRegion()` Get the number of splits per region to use when scanning vertices/edges
    `long` | `getOperationQueueSize()` Get the size of the operation queue
    `HBaseIndexManager` | `getOracleIndexManager()` Gets the OracleIndexManager object associated to this property graph instance.
    `ProgressListener` | `getProgressListener()` Gets the ProgressListener associated to this property graph.
    `int` | `getQueueSize()` This method returns the queue size.
    `int` | `getSaltSize()` Gets the salt size
    `int` | `getScanCachingSize()` Get the caching size used in Scan operations
    `int` | `getSecondaryIndexNumBuckets()` Return the number of buckets used to store secondary index data into the vertex/edge secondary index tables
    `OracleVertex` | `getVertex(Object id)` Return the vertex referenced by the object identifier.
    `int` | `getVertexBlockCacheSize()` Gets the size of the block cache (in bytes) associated to the vertex table
    `VertexFilterCallback` | `getVertexFilterCallback()` Get the VertexFilterCallback associated to this property graph
    `int` | `getVertexInitialNumRegions()` Get the initial number of regions defined for the HBase Vertex tables associated to this property graph.
    `OracleVertexBase` | `getVertexInstance(Long vid, boolean bCreateIfAbsentFromCache, boolean bSkipStoreToCache)` Returns an instance of OracleVertexBase.
    `int` | `getVertexPropertyNames(int dop, int timeout, Set<String> propertyNames)` Gets the property names of all vertices using parallel scans and the specified DOP.
    `int` | `getVertexPropertyNames(int dop, int timeout, Set<String> propertyNames, ProgressListener pl)` Gets the property names of all vertices using parallel scans and the specified DOP.
    `void` | `getVertexPropertyNamesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, Set<String> propertyNames, long lStartTime, long lDeadline, int startSplitID, ProgressListener pl)` The splits are determined by # of regions & m_iNumSplitsPerRegion.
    `int` | `getVertexSndIndexBlockCacheSize()` Gets the size of the block cache (in bytes) associated to the secondary index vertex table
    `String` | `getVertexSndIndexTabName()` Get the name of the HBase table used to store secondary indexes on vertices in this property graph.
    `long` | `getVertexSndIndexWriteBufferSize()` Get the write buffer size associated to the vertex secondary index table
    `int` | `getVertexTableSplits()` Get the number of Vertex table splits based on the current number of splits per region associated to this graph and the number of regions in the vertex table.
    `String` | `getVertexTabName()` Get the name of the HBase table used to store vertices in this property graph.
    `long` | `getVertexWriteBufferSize()` Get the write buffer size associated to the vertex table
    `Iterable<Vertex>` | `getVertices()` Return an iterable to all the vertices in the graph.
    `Iterable<Vertex>` | `getVertices(String key)` Return an iterable to all the vertices in the graph that have a particular key.
    `Iterable<Vertex>` | `getVertices(String[] keys)` Return an iterable to all the vertices in the graph that have any of the specified keys.
    `Iterable<Vertex>` | `getVertices(String[] keys, VertexFilterCallback vfc)` Return an iterable to all the vertices in the graph that have any of the specified keys and satisfy the specifed vertex filter callback.
    `Iterable<Vertex>` | `getVertices(String[] keys, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Return an iterable to all the vertices in the graph that have any of the specified keys and satisfy the specifed vertex filter callback.
    `Iterable<Vertex>` | `getVertices(String key, Object value)` Return an iterable to all matching vertices that have a particular key/value property.
    `Iterable<Vertex>` | `getVertices(String key, Object value, boolean useWildCards)` Return an iterable to all matching vertices that have a particular key/value property.
    `Iterable<Vertex>` | `getVertices(String key, Object value, boolean acceptWildcard, boolean preferredLuceneQuery)` Return an iterable to all matching vertices that have a particular key/value property.
    `Iterable<Vertex>` | `getVertices(String key, Object value, Class dtClass, boolean acceptWildcard)` Return an iterable to all matching vertices that have a particular key/value property.
    `Iterable<Vertex>` | `getVertices(String key, Object value, Class dtClass, boolean acceptWildcard, boolean preferredLuceneQuery)` Return an iterable to all matching vertices that have a particular key/value property.
    `Iterable<Vertex>[]` | `getVerticesFromKey(org.apache.hadoop.hbase.client.HConnection[] conns, boolean skipStoreToCache, int startSplitID, String[] keys)` Return an iterable to all the vertices in the graph that have a particular key/value property.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID)` Gets an array of `Iterable` objects that hold all the vertices in the graph.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, boolean bClonedGraph)` Gets an array of `Iterable` objects that hold all the vertices in the graph.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, OraclePropertyGraphBase.OptimizationFlag flag)` Gets an array of `Iterable` objects that hold all the vertices in the graph.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String key)` Gets an array of `Iterable` objects that hold all the vertices in the graph matching the specified key.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String[] keys)` Gets an array of `Iterable` objects that hold all the vertices in the graph matching any of the specifed keys described in the vertex filter callback.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String[] keys, boolean bCloneGraph, VertexFilterCallback vfc)` Gets an array of `Iterable` objects that hold all the vertices in the graph statisfying the conditions described in the vertex filter callback.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String[] keys, boolean bCloneGraph, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Gets an array of `Iterable` objects that hold all the vertices in the graph statisfying the conditions described in the vertex filter callback.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, String key, boolean bCloneGraph)` Gets an array of `Iterable` objects that hold all the vertices in the graph matching the specified key.
    `Iterable<Vertex>[]` | `getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections, boolean bSkipStoreToCache, int startSplitID, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Gets an array of `Iterable` objects that hold all the vertices in the graph statisfying the conditions described in the vertex filter callback.
    `long` | `getWriteBufferSize()` Get the write buffer size associated to the vertex table
    `boolean` | `isEdgeAutoIndexEnabled(String key)` Validates if the edge auto index is currently enabled
    `boolean` | `isEmpty()` Checks if this property graph is empty
    `boolean` | `isVertexAutoIndexEnabled(String key)` Validates if the vertex auto index is currently enabled
    `static org.apache.hadoop.conf.Configuration` | `prepareSecureConfig(org.apache.hadoop.conf.Configuration config, String hbaseSecAuth, String hadoopSecAuth, String hmKerberosPrincipal, String rsKerberosPrincipal, String userPrincipal, String keytab)` Prepares the HBase configuration object to work with HBase secure cluster
    `GraphQuery` | `query()` Returns a GraphQuery to query for vertices or edges in the graph by their properties.
    `static void` | `quietlyClose(org.apache.hadoop.hbase.client.HTable htable)` Quietly close the specified HTable object.
    `static void` | `quietlyClose(org.apache.hadoop.hbase.client.HTableInterface htable)` Quietly close the specified HTableInterface object.
    `void` | `removeAttributeFromAllEdges(EdgeOpCallback eoc)` Removes an attribute from all edges based on the specified EdgeOpCallback.
    `void` | `removeAttributeFromAllEdges(EdgeOpCallback eoc, boolean skipStoreToCache, int dop)` Removes an attribute from all edges based on the specified EdgeOpCallback.
    `void` | `removeAttributeFromAllEdges(EdgeOpCallback eoc, boolean skipStoreToCache, int dop, ProgressListener pl)` Removes an attribute from all edges based on the specified EdgeOpCallback.
    `void` | `removeAttributeFromAllVertices(VertexOpCallback voc)` Removes an attribute from all vertices based on the specified VertexOpCallback.
    `void` | `removeAttributeFromAllVertices(VertexOpCallback voc, boolean skipStoreToCache, int dop)` Removes an attribute from all vertices based on the specified VertexOpCallback.
    `void` | `removeAttributeFromAllVertices(VertexOpCallback voc, boolean skipStoreToCache, int dop, ProgressListener pl)` Removes an attribute from all vertices based on the specified VertexOpCallback.
    `void` | `removeEdge(Edge edge)` Remove the provided edge from the graph.
    `void` | `removeVertex(Vertex vertex)` Remove the provided vertex from the graph.
    `void` | `rollback()` Rollbacks the operations done to this property graph instance
    `static byte[]` | `saltEdge(byte[] ba)` Salts an edge ID represented as a byte array
    `static byte[]` | `saltVertex(byte[] ba)` Salts a vertex ID represented as a byte array
    `static String` | `serializableToStr(Serializable seri)` Convert from a Java Serializable object to a String encoding.
    `void` | `setBatchSize(int batchsize)` Set the size of the batch used for update operations.
    `void` | `setCompression(String compress)` Set the type of compression used in the property graph tables.
    `void` | `setDataBlockEncoding(org.apache.hadoop.hbase.io.encoding.DataBlockEncoding dbe)` Set the data block encoding used in the property graph tables.
    `void` | `setDefaultEdgeOptFlag(OraclePropertyGraphBase.OptimizationFlag eof)` Set the edge optimization flag associated to this property graph
    `void` | `setDefaultIndexParameters(OracleIndexParameters indexParams)` Set the default index parameters associated to this property graph.
    `void` | `setDefaultVertexOptFlag(OraclePropertyGraphBase.OptimizationFlag vof)` Set the default optimization flag for vertices associated to this property graph
    `void` | `setEdgeBlockCacheSize(int blockCSize)` Set the size of the block cache (in bytes) associated to the edge table This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the edge tables.
    `void` | `setEdgeFilterCallback(EdgeFilterCallback efc)` Set the default EdgeFilterCallback associated to this property graph
    `void` | `setEdgeInitialNumRegions(int numRegions)` Set the initial number of regions defined for the HBase edge tables associated to this property graph.
    `void` | `setEdgeSndIndexBlockCacheSize(int blockCSize)` Set the size of the block cache (in bytes) associated to the edge secondary table This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the edge tables.
    `void` | `setEdgeSndIndexWriteBufferSize(long writebuffer)` Set the size of the write buffer associated to the edge secondary index table
    `void` | `setEdgeWriteBufferSize(long writebuffer)` Set the maximum size of the write buffer associated to the edge table
    `void` | `setIndexLuceneWriteBufferSize(long writebuffer)` Set the maxium size of the write buffer associated to the Lucene index table
    `void` | `setInitialNumRegions(int numRegions)` Set the initial number of regions defined for the HBase tables associated to this property graph.
    `void` | `setLuceneBlockCacheSize(int blockCSize)` Set the size of the block cache (in bytes) associated to the Lucene index table This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the lucene tables.
    `void` | `setNumSplitsPerRegion(int iNumSplitsPerRegion)` Set the number of splits per region to use when scanning vertices/edges
    `void` | `setProgressListener(ProgressListener pl)` Sets the ProgressListener associated to this property graph.
    `void` | `setQueueSize(int size)` This method sets the queue size.
    `void` | `setScanCachingSize(int iScanCachingSize)` Set the caching size used in Scan operations
    `void` | `setVertexBlockCacheSize(int blockCSize)` Set the size of the block cache (in bytes) associated to the vertex table
    `void` | `setVertexFilterCallback(VertexFilterCallback vfc)` Set the default VertexFilterCallback associated to this property graph
    `void` | `setVertexInitialNumRegions(int numRegions)` Set the initial number of regions defined for the HBase Vertex tables associated to this property graph.
    `void` | `setVertexSndIndexBlockCacheSize(int blockCSize)` Set the size of the block cache (in bytes) associated to the vertex secondary table This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the vertex tables.
    `void` | `setVertexSndIndexWriteBufferSize(long writebuffer)` Set the maximum size of the write buffer associated to the vertex secondary index table
    `void` | `setVertexWriteBufferSize(long writebuffer)` Set the maximum size of the write buffer associated to the vertex table
    `void` | `setWriteBufferSize(long writebuffer)` Set the maximum size of the write buffer associated to the graph tables
    `void` | `shutdown()` A shutdown function is required to properly close the graph.
    `void` | `startTransaction()` Start a transaction.
    `void` | `stopTransaction(TransactionalGraph.Conclusion conclusion)` Stop the current transaction.
    `static Object` | `strToSerializable(String s)` Convert from a String encoding to a Serializable object
    `String` | `toString()` Returns a very succinct String representation of this Graph instance

    - ### Methods inherited from class oracle.pg.common.OraclePropertyGraphBase

      `getConfig, getShortestPath, getShortestPath, getVertexPropertyNames, getVertexPropertyNames, sum`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Method Detail

    - #### addAttributeToAllEdges

          public void addAttributeToAllEdges(EdgeOpCallback eoc)

      Adds an attribute to all edges based on the specified EdgeOpCallback.
      Parameters:
        `eoc` - an EdgeOpCallBack object.

    - #### addAttributeToAllEdges

          public void addAttributeToAllEdges(EdgeOpCallback eoc,
                                    boolean skipStoreToCache,
                                    int dop)

      Adds an attribute to all edges based on the specified EdgeOpCallback.
      Parameters:
        `eoc` - an EdgeOpCallBack object.
        `skipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `dop` - a positive integer defining the number of threads to use when parallel processing the edges.

    - #### addAttributeToAllEdges

          public void addAttributeToAllEdges(EdgeOpCallback eoc,
                                    boolean skipStoreToCache,
                                    int dop,
                                    ProgressListener pl)

      Adds an attribute to all edges based on the specified EdgeOpCallback.
      Parameters:
        `eoc` - an EdgeOpCallBack object.
        `skipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `dop` - a positive integer defining the number of threads to use when parallel processing the edges.
        `pl` - a ProgressListener object.

    - #### addAttributeToAllVertices

          public void addAttributeToAllVertices(VertexOpCallback voc)

      Adds an attribute to all vertices based on the specified VertexOpCallback.
      Parameters:
        `voc` - a VertexOpCallBack object.

    - #### addAttributeToAllVertices

          public void addAttributeToAllVertices(VertexOpCallback voc,
                                       boolean skipStoreToCache,
                                       int dop)

      Adds an attribute to all vertices based on the specified VertexOpCallback.
      Parameters:
        `voc` - a VertexOpCallBack object.
        `skipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `dop` - a positive integer defining the number of threads to use when parallel processing the vertices.

    - #### addAttributeToAllVertices

          public void addAttributeToAllVertices(VertexOpCallback voc,
                                       boolean skipStoreToCache,
                                       int dop,
                                       ProgressListener pl)

      Adds an attribute to all vertices based on the specified VertexOpCallback.
      Parameters:
        `voc` - a VertexOpCallBack object.
        `skipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `dop` - a positive integer defining the number of threads to use when parallel processing the vertices.
        `pl` - a ProgressListener object.

    - #### addEdge

          public Edge addEdge(Object id,
                     Vertex outVertex,
                     Vertex inVertex,
                     String label)

      This method adds an edge to the graph instance. Note that this is just a logical operation. Note that this is not a thread safe method.
      Parameters:
        `id` - the id of the vertex
        `outVertex` - has to be of type OracleVertex
        `inVertex` - has to be of type OracleVertex

    - #### addVertex

          public Vertex addVertex(Object id)

      This method adds a vertex to the graph instance. Note that this is just a logical opearation; This is not a thread safe method.
      Parameters:
        `id` - vertex id
      Returns:
        a `Vertex` object

    - #### clearCache

          public void clearCache()

      This method clear the Vertex and Edge caches associated to this property graph instance.

    - #### clearRepository

          public void clearRepository()
                               throws org.apache.hadoop.hbase.MasterNotRunningException,
                                      IOException

      This method removes all vertices and edges from this property graph instance. Additionally, all existing index are removed from this property graph instance. A DDL (truncate) is executed so there is no way to rollback.
      Specified by:
        `clearRepository` in class `OraclePropertyGraphBase`
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `IOException`

    - #### commit

          public void commit()

      Commit changes done to this property graph instace.

    - #### concatenate

          public static byte[] concatenate(byte[] ba1,
                           byte[] ba2)

      This method returns a byte array that concatenates the two given byte array If one of the argument is null, the return value will be the other argument.

    - #### concatenate

          public static byte[] concatenate(byte[] ba1,
                           byte[] ba2,
                           byte[] ba3)

      This method returns a byte array that concatenates the two given byte array If one of the argument is null, the return value will be the other argument.

    - #### countEdges

          public long countEdges()

      Counts all Edges
      Returns:
        number of edges in the graph

    - #### countEdges

          public long countEdges(int dop)

      Counts all Edges using parallel scans and the specified DOP
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the edges.
      Returns:
        the number of edes in the graph

    - #### countEdges

          public long countEdges(int dop,
                        ProgressListener pl)

      Counts all Edges using parallel scan and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the edges.
        `pl` - a ProgressListener object.
      Returns:
        number of edges in the graph

    - #### countEdgesPartitioned

          public long countEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                   int startSplitID,
                                   ProgressListener pl)

      The splits are determined by # of regions & m_iNumSplitsPerRegion. DOP is determined by connections.size()
      Parameters:
        `startSplitID` - starts from 0.

    - #### countVertices

          public long countVertices()

      Counts all vertices
      Returns:
        number of vertices in the graph

    - #### countVertices

          public long countVertices(int dop)

      Counts all vertices using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.
      Returns:
        the number of vertices in the graph

    - #### countVertices

          public long countVertices(int dop,
                           ProgressListener pl)

      Counts all vertices using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.
        `pl` - a ProgressListener object.
      Returns:
        the number of vertices in the graph

    - #### countVerticesPartitioned

          public long countVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                      int startSplitID,
                                      ProgressListener pl)

      The splits are determined by # of regions & m_iNumSplitsPerRegion. DOP is determined by connections.size()
      Parameters:
        `startSplitID` - starts from 0.

    - #### createIndex

          public <T extends Element> Index<T> createIndex(String indexName,
                                                 Class<T> indexClass,
                                                 Parameter... indexParameters)

      Generates an index with a particular name, for a particular class, and of a particular type.
      Parameters:
        `indexName` - the name of the index
        `indexClass` - the element class that this index is indexing (can be base class)
        `indexParameters` - a collection of parameters for the underlying index implementation
      Returns:
        the index created

    - #### createKeyIndex

          public <T extends Element> void createKeyIndex(String[] keys,
                                                Class<T> elementClass)

      Creates an automatically maintained index for the given keys and element class.
      Parameters:
        `keys` - an array of keys to create the index for.
        `elementClass` - the element class that the index is for.

    - #### createKeyIndex

          public <T extends Element> void createKeyIndex(String key,
                                                Class<T> elementClass,
                                                Parameter... parameters)

      Creates an automatic indexing structure for indexing provided key for element class.
      Parameters:
        `key` - the key to create the index for.
        `elementClass` - the element class that the index is for.
        `parameters` - a collection of parameters for the underlying index implementation.

    - #### dropAllAutoIndices

          public void dropAllAutoIndices()

      Drops all existing automatic indices (vertex and edges)

    - #### dropAllIndices

          public void dropAllIndices()

      Drops all existing indices
      Specified by:
        `dropAllIndices` in class `OraclePropertyGraphBase`

    - #### dropAllManualIndices

          public void dropAllManualIndices()

      Drops all existing manual indices (vertices and edges)

    - #### dropIndex

          public void dropIndex(String indexName)

      Removes an index associated with the graph.
      Parameters:
        `indexName` - the name of the index to drop

    - #### dropIndexTable

          public void dropIndexTable()
                              throws org.apache.hadoop.hbase.MasterNotRunningException,
                                     IOException

      This method removes all indices meta data from this property graph instance. A DDL (truncate) is executed so there is no way to rollback.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `IOException`

    - #### dropKeyIndex

          public <T extends Element> void dropKeyIndex(String[] keys,
                                              Class<T> elementClass)

      Removes an automatic indexing structure associated with indexing provided key for element class.
      Parameters:
        `keys` - an array of keys to drop the index for.
        `elementClass` - the element class that the index is for.

    - #### dropKeyIndex

          public <T extends Element> void dropKeyIndex(String key,
                                              Class<T> elementClass)

      Removes an automatic indexing structure associated with indexing provided key for element class.
      Parameters:
        `key` - the key to drop the index for.
        `elementClass` - the element class that the index is for.

    - #### flushHbaseCommits

          public void flushHbaseCommits()

      Flush HBase tables so property grpah changes are commited into HBase.

    - #### getAutoIndex

          public <T extends Element> Index<T> getAutoIndex(Class<T> indexClass)

      Gets an index from the graph by its name and index class. An index is unique up to name.

    - #### getBatchSize

          public int getBatchSize()

      Get the size of the batch used for update operations.

    - #### getCompression

          public String getCompression()

      Get the type of compression used in the property graph tables
      Returns:
        the compression used in the property graph tables

    - #### getCompressionAlgorithm

          public org.apache.hadoop.hbase.io.compress.Compression.Algorithm getCompressionAlgorithm(String compress)

      An utility to get a Compression Algorithm based on the specified string

    - #### getConfiguration

          public org.apache.hadoop.conf.Configuration getConfiguration()

      This method returns the underlying Configuration instance used for HBase

    - #### getDataBlockEncoding

          public org.apache.hadoop.hbase.io.encoding.DataBlockEncoding getDataBlockEncoding()

      Gets the data block encoding algorithm used in block cache and optionally on disk for all property graph tables

    - #### getDefaultEdgeOptFlag

          public OraclePropertyGraphBase.OptimizationFlag getDefaultEdgeOptFlag()

      Get the OptimizationFlag for edges associated to this property graph

    - #### getDefaultIndexParameters

          public OracleIndexParameters getDefaultIndexParameters()

      Get the default index parameters associated to this property graph. The index parameters provided here will be used when an automatic or manual index is to be created without an explicit specification of the index parameters.
      Specified by:
        `getDefaultIndexParameters` in class `OraclePropertyGraphBase`
      Returns:
        a `OracleIndexParameters` object.

    - #### getDefaultVertexOptFlag

          public OraclePropertyGraphBase.OptimizationFlag getDefaultVertexOptFlag()

      Get the OptimizationFlag for vertices associated to this property graph

    - #### getEdge

          public OracleEdge getEdge(Object id)

      Return the edge referenced by the object identifier.

    - #### getEdgeBlockCacheSize

          public int getEdgeBlockCacheSize()

      Gets the size of the block cache (in bytes) associated to the edge table

    - #### getEdgeFilterCallback

          public EdgeFilterCallback getEdgeFilterCallback()

      Get the EdgeFilterCallback associated to this property graph

    - #### getEdgeInitialNumRegions

          public int getEdgeInitialNumRegions()

      Get the initial number of regions defined for the HBase Edge tables associated to this property graph. Default value is set to 24 regions.
      Returns:
        the initial number of regions.

    - #### getEdgeInstance

          public OracleEdgeBase getEdgeInstance(Long eid,
                                       boolean bCreateIfAbsentFromCache,
                                       boolean bSkipStoreToCache)

      Returns an instance of OracleEdgeBase. If there is no match in the cache and bCreateIfAbsentFromCache is false, then a NULL value will be returned.
      Specified by:
        `getEdgeInstance` in class `OraclePropertyGraphBase`

    - #### getEdgeInstance

          public OracleEdgeBase getEdgeInstance(OracleVertexBase outVertex,
                                       OracleVertexBase inVertex,
                                       String edgeLabel,
                                       Long eid,
                                       boolean bCreateIfAbsentFromCache,
                                       boolean bSkipStoreToCache)

      Returns an instance of OracleEdge
      Specified by:
        `getEdgeInstance` in class `OraclePropertyGraphBase`

    - #### getEdgePropertyNames

          public int getEdgePropertyNames(int dop,
                                 int timeout,
                                 Set<String> propertyNames)

      Gets the property names of all edges.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the edges
        `timeout` - time out in the unit of seconds
        `propertyNames` - a set of property names to be returned

    - #### getEdgePropertyNames

          public int getEdgePropertyNames(int dop,
                                 int timeout,
                                 Set<String> propertyNames,
                                 ProgressListener pl)

      Gets the property names of all edges using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the edges
        `timeout` - time out in the unit of seconds
        `propertyNames` - a set of property names to be returned
        `pl` - a ProgressListener object.

    - #### getEdgePropertyNamesPartitioned

          public void getEdgePropertyNamesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             Set<String> propertyNames,
                                             long lStartTime,
                                             long lDeadline,
                                             int startSplitID,
                                             ProgressListener pl)

      The splits are determined by # of regions & m_iNumSplitsPerRegion. DOP is determined by connections.size()
      Parameters:
        `startSplitID` - starts from 0.

    - #### getEdges

          public Iterable<Edge> getEdges()

      Return an Iterable to all the edges in the graph.

    - #### getEdges

          public Iterable<Edge> getEdges(String key)

      Return an iterable to all the edges in the graph that have a particular key.
      Specified by:
        `getEdges` in class `OraclePropertyGraphBase`
      Parameters:
        `key` - name of the property. It can be NULL which implies all edges in the graph will be returned.

    - #### getEdges

          public Iterable<Edge> getEdges(String[] keys)

      Return an iterable to all the edges in the graph that have any of the specified keys.
      Specified by:
        `getEdges` in class `OraclePropertyGraphBase`
      Parameters:
        `keys` - an array of property key names. It can be NULL which implies all edges in the graph will be returned.

    - #### getEdges

          public Iterable<Edge> getEdges(String[] keys,
                                EdgeFilterCallback efc)

      Return an iterable to all the edges in the graph that have any of the specified keys and satisfy the specifed edge filter callback.
      Parameters:
        `keys` - an array of property key names. It can be NULL which implies all edges in the graph satisfying the edge filter callback will be returned.
        `efc` - a `EdgeFilterCallback` object specifying the conditions to keep an edge in the iterable.

    - #### getEdges

          public Iterable<Edge> getEdges(String[] keys,
                                EdgeFilterCallback efc,
                                OraclePropertyGraphBase.OptimizationFlag flag)

      Return an iterable to all the edges in the graph that have any of the specified keys and satisfy the specifed edge filter callback.
      Parameters:
        `keys` - an array of property key names. It can be NULL which implies all vertices in the graph satisfying the edge filter callback will be returned.
        `efc` - a `EdgeFilterCallback` object specifying the conditions to keep a edge in the iterable.
        `flag` - an OptimizationFlag object specifying if a partial or complete edge object will be returned. It can be NULL which implies the edges created must be complete.

    - #### getEdges

          public Iterable<Edge> getEdges(String key,
                                Object value)

      Return an iterable to all matching edges that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching edges.
      Parameters:
        `key` - the name of the property. It MUST not be NULL.
        `value` - the value of the property. It can be NULL which will cause all edges with the given key to be returned.

    - #### getEdges

          public Iterable<Edge> getEdges(String key,
                                Object value,
                                boolean useWildCard)

      Return an iterable to all matching edges that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching edges.
      Specified by:
        `getEdges` in class `OraclePropertyGraphBase`
      Parameters:
        `key` - the name of the property. It MUST not be NULL.
        `value` - the value of the property. It can be NULL which will cause all edges with the given key to be returned.
        `useWildCard` - specifies if wild cards can be used in the value object. Wild cards can be used only when an automatic text index on the given key is present.

    - #### getEdges

          public Iterable<Edge> getEdges(String key,
                                Object value,
                                boolean acceptWildcard,
                                boolean preferredLuceneQuery)

      Return an iterable to all the vertices in the graph that have a particular key/value property.

    - #### getEdges

          public Iterable<Edge> getEdges(String key,
                                Object value,
                                Class dtClass,
                                boolean acceptWildcard)

      Return an iterable to all matching edges that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching edges.
      Specified by:
        `getEdges` in class `OraclePropertyGraphBase`
      Parameters:
        `key` - the name of the property. It MUST not be NULL.
        `value` - the value of the property. It can be NULL which will cause all edges with the given key to be returned.
        `dtClass` - the datatype of the value object
        `acceptWildcard` - specifies if wild cards can be used in the value object. Wild cards can be used only when an automatic text index on the given key is present.

    - #### getEdges

          public Iterable<Edge> getEdges(String key,
                                Object value,
                                Class dtClass,
                                boolean acceptWildcard,
                                boolean preferredLuceneQuery)

      Return an iterable to all the vertices in the graph that have a particular key/value property.

    - #### getEdgesFromKey

          public Iterable<Edge>[] getEdgesFromKey(org.apache.hadoop.hbase.client.HConnection[] conns,
                                         boolean skipStoreToCache,
                                         int startSplitID,
                                         String[] keys)

      Return an iterable to all the edges in the graph that have a particular key/value property.

    - #### getEdgeSndIndexBlockCacheSize

          public int getEdgeSndIndexBlockCacheSize()

      Gets the size of the block cache (in bytes) associated to the secondary index edge table

    - #### getEdgeSndIndexTabName

          public String getEdgeSndIndexTabName()

      Get the name of the HBase table used to store secondary indexes on edges in this property graph.
      Returns:
        the edge secondary index table name.

    - #### getEdgeSndIndexWriteBufferSize

          public long getEdgeSndIndexWriteBufferSize()

      Set the write buffer size associated to the edge secondary index table
      Returns:
        the size of the write buffer used in the edge secondary index table

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             boolean bClonedGraph)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             EdgeFilterCallback efc)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             EdgeFilterCallback efc,
                                             OraclePropertyGraphBase.OptimizationFlag flag)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `flag` - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             OraclePropertyGraphBase.OptimizationFlag flag)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `flag` - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             String key)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             String[] keys)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             String[] keys,
                                             boolean bClonedGraph,
                                             EdgeFilterCallback efc)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             String[] keys,
                                             boolean bClonedGraph,
                                             EdgeFilterCallback efc,
                                             OraclePropertyGraphBase.OptimizationFlag flag)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `flag` - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgesPartitioned

          public Iterable<Edge>[] getEdgesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                             boolean bSkipStoreToCache,
                                             int startSplitID,
                                             String key,
                                             boolean bClonedGraph)

      Gets an array of `Iterable` objects that hold all the edges in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getEdgeTableSplits

          public int getEdgeTableSplits()
                                 throws IOException

      Get the number of Edge table splits based on the current number of splits per region associated to this graph and the number of regions in the edge table.
      Returns:
        the number of splits in the edge table
      Throws:
        `IOException`

    - #### getEdgeTabName

          public String getEdgeTabName()

      Get the name of the HBase table used to store edges in this property graph.
      Returns:
        the edge table name.

    - #### getEdgeWriteBufferSize

          public long getEdgeWriteBufferSize()

      Set the write buffer size associated to the edge table
      Returns:
        the size of the write buffer used in the edge table

    - #### getFeatures

          public Features getFeatures()

      Get the particular features of the graph implementation.

    - #### getGraphName

          public String getGraphName()

      This method returns the name of this property graph instance
      Overrides:
        `getGraphName` in class `OraclePropertyGraphBase`

    - #### getIndex

          public <T extends Element> Index<T> getIndex(String indexName,
                                              Class<T> indexClass)

      Gets a manual index from the graph by its name and index class. An index is unique up to name.

    - #### getIndexedKeys

          public <T extends Element> Set<String> getIndexedKeys(Class<T> elementClass)

      Returns all the index keys associated with a particular element class.
      Parameters:
        `elementClass` - the element class that the index is for.
      Returns:
        the indexed keys as a Set.

    - #### getIndexParameters

          public <T extends Element> OracleIndexParameters getIndexParameters(String indexName,
                                                                     Class<T> indexClass)

      Get the index parameters associated to this property graph.
      Returns:
        a `OracleIndexParameters` object.

    - #### getIndices

          public Iterable<Index<? extends Element>> getIndices()

      Gets all the indices maintained by the graph.
      Returns:
        the indices associated with the graph

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName,
                                        int initialNumRegions)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
        `initialNumRegions` - the initial number of regions used for vertex/edge tables. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName,
                                        int initialNumRegions,
                                        int splitsPerRegion)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
        `initialNumRegions` - the initial number of regions used for vertex/edge tables. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
        `splitsPerRegion` - a positive integer specifying the number of splits per region to use when scanning vertices/edges.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName,
                                        int initialNumRegions,
                                        int splitsPerRegion,
                                        int blockCacheSize)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
        `initialNumRegions` - the initial number of regions used for vertex/edge tables. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
        `splitsPerRegion` - a positive integer specifying the number of splits per region to use when scanning vertices/edges.
        `blockCacheSize` - the size of the block cache (in bytes) used for vertex/edge tables. Blocksize to use when writing out storefiles/hfiles on these tables.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName,
                                        String compress,
                                        org.apache.hadoop.hbase.io.encoding.DataBlockEncoding dbe,
                                        int splitsPerRegion,
                                        int blockCacheSize,
                                        int initialVertexNumRegions,
                                        int initialEdgeNumRegions)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
        `compress` - the compression used in the property graph tables
        `dbe` - the data block encoding used in the property graph tables
        `splitsPerRegion` - a positive integer specifying the number of splits per region to use when scanning vertices/edges.
        `blockCacheSize` - the size of the block cache (in bytes) used for vertex/edge tables. Blocksize to use when writing out storefiles/hfiles on these tables.
        `initialVertexNumRegions` - the initial number of regions used for vertex table. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
        `initialEdgeNumRegions` - the initial number of regions used for edge table. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName,
                                        String compress,
                                        int initialNumRegions)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
        `compress` - the compression used in the property graph tables
        `initialNumRegions` - the initial number of regions used for vertex/edge tables. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName,
                                        String compress,
                                        int initialNumRegions,
                                        int splitsPerRegion)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
        `compress` - the compression used in the property graph tables
        `initialNumRegions` - the initial number of regions used for vertex/edge tables. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
        `splitsPerRegion` - a positive integer specifying the number of splits per region to use when scanning vertices/edges.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName,
                                        String compress,
                                        int initialNumRegions,
                                        int splitsPerRegion,
                                        int blockCacheSize)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
        `compress` - the compression used in the property graph tables
        `initialNumRegions` - the initial number of regions used for vertex/edge tables. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
        `splitsPerRegion` - a positive integer specifying the number of splits per region to use when scanning vertices/edges.
        `blockCacheSize` - the size of the block cache (in bytes) used for vertex/edge tables. Blocksize to use when writing out storefiles/hfiles on these tables.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(org.apache.hadoop.conf.Configuration conf,
                                        org.apache.hadoop.hbase.client.HConnection hconn,
                                        String szGraphName,
                                        String compress,
                                        int splitsPerRegion,
                                        int blockCacheSize,
                                        int initialVertexNumRegions,
                                        int initialEdgeNumRegions)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `szGraphName` - the name of the graph
        `compress` - the compression used in the property graph tables
        `splitsPerRegion` - a positive integer specifying the number of splits per region to use when scanning vertices/edges.
        `blockCacheSize` - the size of the block cache (in bytes) used for vertex/edge tables. Blocksize to use when writing out storefiles/hfiles on these tables.
        `initialVertexNumRegions` - the initial number of regions used for vertex table. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
        `initialEdgeNumRegions` - the initial number of regions used for edge table. Both vertex and edge tables will be created using the specified number of regions. If the graph already exists, a clearRepository operation must be executed in order to truncate the tables and set the new number of regions.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstance

          public static OraclePropertyGraph getInstance(oracle.pgx.config.PgHbaseGraphConfig config)
                                                 throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                        org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                        IOException

      Returns an instance of OraclePropertyGraph using a PGX PgHbaseGraphConfig object.
      Parameters:
        `config` - a `PgHbaseGraphConfig` object.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getInstanceWithSplits

          public static OraclePropertyGraph getInstanceWithSplits(org.apache.hadoop.conf.Configuration conf,
                                                  org.apache.hadoop.hbase.client.HConnection hconn,
                                                  String szGraphName,
                                                  int splitsPerRegion)
                                                           throws org.apache.hadoop.hbase.MasterNotRunningException,
                                                                  org.apache.hadoop.hbase.ZooKeeperConnectionException,
                                                                  IOException

      Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided and the specified number of splits per region.
      Parameters:
        `conf` - the Configuration object with all the HBase connection information.
        `hconn` - an `HConnection` object handling a connection to HBase.
        `splitsPerRegion` - a positive integer specifying the number of splits per region to use when scanning vertices/edges.
      Throws:
        `org.apache.hadoop.hbase.MasterNotRunningException`
        `org.apache.hadoop.hbase.ZooKeeperConnectionException`
        `IOException`

    - #### getLuceneBlockCacheSize

          public int getLuceneBlockCacheSize()

      Gets the size of the block cache (in bytes) associated to the Lucene index table

    - #### getLuceneTabName

          public String getLuceneTabName()

      Get the name of the HBase table used to store index metadata in this property graph.
      Returns:
        the index table name.

    - #### getLuceneWriteBufferSize

          public long getLuceneWriteBufferSize()

      Set the write buffer size associated to the Lucene index table
      Returns:
        the size of the write buffer used in the index table

    - #### getMaxEdgeID

          public long getMaxEdgeID()

      Get max edge ID

    - #### getMaxEdgeID

          public long getMaxEdgeID(int dop)

      Get max edge ID using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.

    - #### getMaxEdgeID

          public long getMaxEdgeID(int dop,
                          ProgressListener pl)

      Get the maximal edge ID using parallel scan and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.
        `pl` - a ProgressListener object.
      Returns:
        maximal edge ID in the graph

    - #### getMaxVertexID

          public long getMaxVertexID()

      Get min Vertex ID

    - #### getMaxVertexID

          public long getMaxVertexID(int dop)

      Get min vertex ID using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.

    - #### getMaxVertexID

          public long getMaxVertexID(int dop,
                            ProgressListener pl)

      Get min vertex ID using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.

    - #### getMinEdgeID

          public long getMinEdgeID()

      Get min edge ID

    - #### getMinEdgeID

          public long getMinEdgeID(int dop)

      Get min edge ID using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.

    - #### getMinEdgeID

          public long getMinEdgeID(int dop,
                          ProgressListener pl)

      Get the minimum edge ID using parallel scan and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.
        `pl` - a ProgressListener object.
      Returns:
        minimum edge ID in the graph

    - #### getMinVertexID

          public long getMinVertexID()

      Get min Vertex ID

    - #### getMinVertexID

          public long getMinVertexID(int dop)

      Get min vertex ID using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.

    - #### getMinVertexID

          public long getMinVertexID(int dop,
                            ProgressListener pl)

      Get min vertex ID using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices.

    - #### getNumSplitsPerRegion

          public int getNumSplitsPerRegion()

      Get the number of splits per region to use when scanning vertices/edges
      Returns:
        the number of splits per region

    - #### getOperationQueueSize

          public long getOperationQueueSize()

      Get the size of the operation queue

    - #### getOracleIndexManager

          public HBaseIndexManager getOracleIndexManager()

      Gets the OracleIndexManager object associated to this property graph instance.
      Specified by:
        `getOracleIndexManager` in class `OraclePropertyGraphBase`
      Returns:
        a `HBaseIndexManager` object.

    - #### getProgressListener

          public ProgressListener getProgressListener()

      Gets the ProgressListener associated to this property graph.
      Returns:
        a ProgressListener object.

    - #### getQueueSize

          public int getQueueSize()

      This method returns the queue size.
      Returns:
        the size of the queue

    - #### getSaltSize

          public int getSaltSize()

      Gets the salt size
      Returns:
        the salt size

    - #### getScanCachingSize

          public int getScanCachingSize()

      Get the caching size used in Scan operations
      Returns:
        the cache size used in Scan operations.

    - #### getSecondaryIndexNumBuckets

          public int getSecondaryIndexNumBuckets()

      Return the number of buckets used to store secondary index data into the vertex/edge secondary index tables
      Returns:
        the number of buckets used to store secondary index data

    - #### getVertex

          public OracleVertex getVertex(Object id)

      Return the vertex referenced by the object identifier.

    - #### getVertexBlockCacheSize

          public int getVertexBlockCacheSize()

      Gets the size of the block cache (in bytes) associated to the vertex table

    - #### getVertexFilterCallback

          public VertexFilterCallback getVertexFilterCallback()

      Get the VertexFilterCallback associated to this property graph

    - #### getVertexInitialNumRegions

          public int getVertexInitialNumRegions()

      Get the initial number of regions defined for the HBase Vertex tables associated to this property graph. Default value is set to 24 regions.
      Returns:
        the initial number of regions.

    - #### getVertexInstance

          public OracleVertexBase getVertexInstance(Long vid,
                                           boolean bCreateIfAbsentFromCache,
                                           boolean bSkipStoreToCache)

      Returns an instance of OracleVertexBase. If there is no match in the cache and bCreateIfAbsentFromCache is false, then a NULL value will be returned.
      Specified by:
        `getVertexInstance` in class `OraclePropertyGraphBase`

    - #### getVertexPropertyNames

          public int getVertexPropertyNames(int dop,
                                   int timeout,
                                   Set<String> propertyNames)

      Gets the property names of all vertices using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices
        `timeout` - time out in the unit of seconds
        `propertyNames` - a set of property names to be returned

    - #### getVertexPropertyNames

          public int getVertexPropertyNames(int dop,
                                   int timeout,
                                   Set<String> propertyNames,
                                   ProgressListener pl)

      Gets the property names of all vertices using parallel scans and the specified DOP.
      Parameters:
        `dop` - a positive integer defining the number of threads to use when parallel scanning the vertices
        `timeout` - time out in the unit of seconds
        `propertyNames` - a set of property names to be returned
        `pl` - a ProgressListener object.

    - #### getVertexPropertyNamesPartitioned

          public void getVertexPropertyNamesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                               Set<String> propertyNames,
                                               long lStartTime,
                                               long lDeadline,
                                               int startSplitID,
                                               ProgressListener pl)

      The splits are determined by # of regions & m_iNumSplitsPerRegion. DOP is determined by connections.size()
      Parameters:
        `startSplitID` - starts from 0.

    - #### getVertexSndIndexBlockCacheSize

          public int getVertexSndIndexBlockCacheSize()

      Gets the size of the block cache (in bytes) associated to the secondary index vertex table

    - #### getVertexSndIndexTabName

          public String getVertexSndIndexTabName()

      Get the name of the HBase table used to store secondary indexes on vertices in this property graph.
      Returns:
        the vertex table name.

    - #### getVertexSndIndexWriteBufferSize

          public long getVertexSndIndexWriteBufferSize()

      Get the write buffer size associated to the vertex secondary index table
      Returns:
        the size of the write buffer used in the vertex secondary index table

    - #### getVertexTableSplits

          public int getVertexTableSplits()
                                   throws IOException

      Get the number of Vertex table splits based on the current number of splits per region associated to this graph and the number of regions in the vertex table.
      Returns:
        the number of splits in the vertex table
      Throws:
        `IOException`

    - #### getVertexTabName

          public String getVertexTabName()

      Get the name of the HBase table used to store vertices in this property graph.
      Returns:
        the vertex table name.

    - #### getVertexWriteBufferSize

          public long getVertexWriteBufferSize()

      Get the write buffer size associated to the vertex table
      Returns:
        the size of the write buffer used in the vertex table

    - #### getVertices

          public Iterable<Vertex> getVertices()

      Return an iterable to all the vertices in the graph.

    - #### getVertices

          public Iterable<Vertex> getVertices(String key)

      Return an iterable to all the vertices in the graph that have a particular key.
      Specified by:
        `getVertices` in class `OraclePropertyGraphBase`
      Parameters:
        `key` - name of the property. It can be NULL which implies all vertices in the graph will be returned.

    - #### getVertices

          public Iterable<Vertex> getVertices(String[] keys)

      Return an iterable to all the vertices in the graph that have any of the specified keys.
      Specified by:
        `getVertices` in class `OraclePropertyGraphBase`
      Parameters:
        `keys` - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.

    - #### getVertices

          public Iterable<Vertex> getVertices(String[] keys,
                                     VertexFilterCallback vfc)

      Return an iterable to all the vertices in the graph that have any of the specified keys and satisfy the specifed vertex filter callback.
      Parameters:
        `keys` - an array of property key names. It can be NULL which implies all vertices in the graph satisfying the vertex filter callback will be returned.
        `vfc` - a `VertexFilterCallback` object specifying the conditions to keep a vertex in the iterable.

    - #### getVertices

          public Iterable<Vertex> getVertices(String[] keys,
                                     VertexFilterCallback vfc,
                                     OraclePropertyGraphBase.OptimizationFlag flag)

      Return an iterable to all the vertices in the graph that have any of the specified keys and satisfy the specifed vertex filter callback.
      Parameters:
        `keys` - an array of property key names. It can be NULL which implies all vertices in the graph satisfying the vertex filter callback will be returned.
        `vfc` - a `VertexFilterCallback` object specifying the conditions to keep a vertex in the iterable.
        `flag` - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.

    - #### getVertices

          public Iterable<Vertex> getVertices(String key,
                                     Object value)

      Return an iterable to all matching vertices that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching vertices.
      Parameters:
        `key` - the name of the property. It MUST not be NULL.
        `value` - the value of the property. It can be NULL which will cause all vertices with the given key to be returned.

    - #### getVertices

          public Iterable<Vertex> getVertices(String key,
                                     Object value,
                                     boolean useWildCards)

      Return an iterable to all matching vertices that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching vertices.
      Specified by:
        `getVertices` in class `OraclePropertyGraphBase`
      Parameters:
        `key` - the name of the property. It MUST not be NULL.
        `value` - the value of the property. It can be NULL which will cause all vertices with the given key to be returned.
        `useWildCards` - specifies if wild cards can be used in the value object. Wild cards can be used only when an automatic text index on the given key is present.

    - #### getVertices

          public Iterable<Vertex> getVertices(String key,
                                     Object value,
                                     boolean acceptWildcard,
                                     boolean preferredLuceneQuery)

      Return an iterable to all matching vertices that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching vertices.
      Parameters:
        `key` - the name of the property. It MUST not be NULL.
        `value` - the value of the property. It can be NULL which will cause all vertices with the given key to be returned.
        `acceptWildcard` - specifies if wild cards can be used in the value object. Wild cards can be used only when an automatic text index on the given key is present.
        `preferredLuceneQuery` - if true, a look up to the automatic index will be executed to find the matches.

    - #### getVertices

          public Iterable<Vertex> getVertices(String key,
                                     Object value,
                                     Class dtClass,
                                     boolean acceptWildcard)

      Return an iterable to all matching vertices that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching vertices.
      Specified by:
        `getVertices` in class `OraclePropertyGraphBase`
      Parameters:
        `key` - the name of the property. It MUST not be NULL.
        `value` - the value of the property. It can be NULL which will cause all vertices with the given key to be returned.
        `dtClass` - the datatype of the value object
        `acceptWildcard` - specifies if wild cards can be used in the value object. Wild cards can be used only when an automatic text index on the given key is present.

    - #### getVertices

          public Iterable<Vertex> getVertices(String key,
                                     Object value,
                                     Class dtClass,
                                     boolean acceptWildcard,
                                     boolean preferredLuceneQuery)

      Return an iterable to all matching vertices that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching vertices.
      Parameters:
        `key` - the name of the property. It MUST not be NULL.
        `value` - the value of the property. It can be NULL which will cause all vertices with the given key to be returned.
        `dtClass` - the datatype of the value object
        `acceptWildcard` - specifies if wild cards can be used in the value object. Wild cards can be used only when an automatic text index on the given key is present.
        `preferredLuceneQuery` - if true, a look up to the automatic index will be executed to find the matches.

    - #### getVerticesFromKey

          public Iterable<Vertex>[] getVerticesFromKey(org.apache.hadoop.hbase.client.HConnection[] conns,
                                              boolean skipStoreToCache,
                                              int startSplitID,
                                              String[] keys)

      Return an iterable to all the vertices in the graph that have a particular key/value property.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID)

      Gets an array of `Iterable` objects that hold all the vertices in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID,
                                                  boolean bClonedGraph)

      Gets an array of `Iterable` objects that hold all the vertices in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID,
                                                  OraclePropertyGraphBase.OptimizationFlag flag)

      Gets an array of `Iterable` objects that hold all the vertices in the graph. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `flag` - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
        `startSplitID` - the ID of the starting split.
      Returns:
        a `Iterable` object.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID,
                                                  String key)

      Gets an array of `Iterable` objects that hold all the vertices in the graph matching the specified key. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
        `key` - the key property name
      Returns:
        a `Iterable` object.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID,
                                                  String[] keys)

      Gets an array of `Iterable` objects that hold all the vertices in the graph matching any of the specifed keys described in the vertex filter callback. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
        `keys` - an array of property keys
      Returns:
        a `Iterable` object.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID,
                                                  String[] keys,
                                                  boolean bCloneGraph,
                                                  VertexFilterCallback vfc)

      Gets an array of `Iterable` objects that hold all the vertices in the graph statisfying the conditions described in the vertex filter callback. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
        `vfc` - a `VertexFilterCallback` object.
        `keys` - an array of property keys
      Returns:
        a `Iterable` object.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID,
                                                  String[] keys,
                                                  boolean bCloneGraph,
                                                  VertexFilterCallback vfc,
                                                  OraclePropertyGraphBase.OptimizationFlag flag)

      Gets an array of `Iterable` objects that hold all the vertices in the graph statisfying the conditions described in the vertex filter callback. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
        `vfc` - a `VertexFilterCallback` object.
        `keys` - an array of property keys
      Returns:
        a `Iterable` object.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID,
                                                  String key,
                                                  boolean bCloneGraph)

      Gets an array of `Iterable` objects that hold all the vertices in the graph matching the specified key. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
        `key` - the key property name
      Returns:
        a `Iterable` object.

    - #### getVerticesPartitioned

          public Iterable<Vertex>[] getVerticesPartitioned(org.apache.hadoop.hbase.client.HConnection[] connections,
                                                  boolean bSkipStoreToCache,
                                                  int startSplitID,
                                                  VertexFilterCallback vfc,
                                                  OraclePropertyGraphBase.OptimizationFlag flag)

      Gets an array of `Iterable` objects that hold all the vertices in the graph statisfying the conditions described in the vertex filter callback. Each element in the `Iterable` array uses a separate connection provided to fetch a subset of the results from the corresponding split. The splits are determined by # of regions & num of splits per region for the table. Note that we assign an integer ID (in the range of [0, N - 1]) to all the splits in the vertex table with N splits. The subset of splits queried will consist of those splits with ID value in the range of [startSplitID, startSplit - 1 + size of connections array].
      Parameters:
        `connections` - an array of connections to Apache HBase.
        `bSkipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `startSplitID` - the ID of the starting split.
        `vfc` - a `VertexFilterCallback` object.
        `flag` - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
      Returns:
        a `Iterable` object.

    - #### getWriteBufferSize

          public long getWriteBufferSize()

      Get the write buffer size associated to the vertex table
      Returns:
        the size of the write buffer used in the vertex table

    - #### isEdgeAutoIndexEnabled

          public boolean isEdgeAutoIndexEnabled(String key)

      Validates if the edge auto index is currently enabled

    - #### isEmpty

          public boolean isEmpty()
                          throws IOException

      Checks if this property graph is empty
      Throws:
        `IOException`

    - #### isVertexAutoIndexEnabled

          public boolean isVertexAutoIndexEnabled(String key)

      Validates if the vertex auto index is currently enabled

    - #### prepareSecureConfig

          public static org.apache.hadoop.conf.Configuration prepareSecureConfig(org.apache.hadoop.conf.Configuration config,
                                                                 String hbaseSecAuth,
                                                                 String hadoopSecAuth,
                                                                 String hmKerberosPrincipal,
                                                                 String rsKerberosPrincipal,
                                                                 String userPrincipal,
                                                                 String keytab)

      Prepares the HBase configuration object to work with HBase secure cluster
      Parameters:
        `config` - the HBase configuration object
        `hbaseSecAuth` - the hbase authentication kerberos/simple
        `hadoopSecAuth` - the hadoop authentication kerberos/simple
        `hmKerberosPrincipal` - The kerberos principal name that should be used to run the HMaster process. The principal name should be in the form: user/hostname@DOMAIN. If "_HOST" is used as the hostname portion, it will be replaced with the actual hostname of the running instance.
        `rsKerberosPrincipal` - Ex. "hbase/_HOST@EXAMPLE.COM".The kerberos principal name that should be used to run the HRegionServer process. The principal name should be in the form: user/hostname@DOMAIN. If _HOST is used as the hostname portion, it will be replaced with the actual hostname of the running instance.
        `userPrincipal` - the user to login
        `keytab` - the keytab containing the password of the login
      Returns:
        a `Configuration` Configuration object.

    - #### query

          public GraphQuery query()

      Returns a GraphQuery to query for vertices or edges in the graph by their properties.

    - #### quietlyClose

          public static void quietlyClose(org.apache.hadoop.hbase.client.HTable htable)

      Quietly close the specified HTable object.
      Parameters:
        `htable` - the HTable object to close.

    - #### quietlyClose

          public static void quietlyClose(org.apache.hadoop.hbase.client.HTableInterface htable)

      Quietly close the specified HTableInterface object.
      Parameters:
        `htable` - the HTable object to close.

    - #### removeAttributeFromAllEdges

          public void removeAttributeFromAllEdges(EdgeOpCallback eoc)

      Removes an attribute from all edges based on the specified EdgeOpCallback.
      Parameters:
        `eoc` - an EdgeOpCallBack object.

    - #### removeAttributeFromAllEdges

          public void removeAttributeFromAllEdges(EdgeOpCallback eoc,
                                         boolean skipStoreToCache,
                                         int dop)

      Removes an attribute from all edges based on the specified EdgeOpCallback.
      Parameters:
        `eoc` - an EdgeOpCallBack object.
        `skipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `dop` - a positive integer defining the number of threads to use when parallel processing the edges.

    - #### removeAttributeFromAllEdges

          public void removeAttributeFromAllEdges(EdgeOpCallback eoc,
                                         boolean skipStoreToCache,
                                         int dop,
                                         ProgressListener pl)

      Removes an attribute from all edges based on the specified EdgeOpCallback.
      Parameters:
        `eoc` - an EdgeOpCallBack object.
        `skipStoreToCache` - if true, the edges instances will not be stored into the cache.
        `dop` - a positive integer defining the number of threads to use when parallel processing the edges.
        `pl` - a ProgressListener object.

    - #### removeAttributeFromAllVertices

          public void removeAttributeFromAllVertices(VertexOpCallback voc)

      Removes an attribute from all vertices based on the specified VertexOpCallback.
      Parameters:
        `voc` - a VertexOpCallBack object.

    - #### removeAttributeFromAllVertices

          public void removeAttributeFromAllVertices(VertexOpCallback voc,
                                            boolean skipStoreToCache,
                                            int dop)

      Removes an attribute from all vertices based on the specified VertexOpCallback.
      Parameters:
        `voc` - a VertexOpCallBack object.
        `skipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `dop` - a positive integer defining the number of threads to use when parallel processing the vertices.

    - #### removeAttributeFromAllVertices

          public void removeAttributeFromAllVertices(VertexOpCallback voc,
                                            boolean skipStoreToCache,
                                            int dop,
                                            ProgressListener pl)

      Removes an attribute from all vertices based on the specified VertexOpCallback.
      Parameters:
        `voc` - a VertexOpCallBack object.
        `skipStoreToCache` - if true, the vertices instances will not be stored into the cache.
        `dop` - a positive integer defining the number of threads to use when parallel processing the vertices.
        `pl` - a ProgressListener object.

    - #### removeEdge

          public void removeEdge(Edge edge)

      Remove the provided edge from the graph.

    - #### removeVertex

          public void removeVertex(Vertex vertex)

      Remove the provided vertex from the graph.

    - #### rollback

          public void rollback()

      Rollbacks the operations done to this property graph instance

    - #### saltEdge

          public static byte[] saltEdge(byte[] ba)

      Salts an edge ID represented as a byte array
      Parameters:
        `ba` - the edge ID represented as a byte array
      Returns:
        a salted byte array

    - #### saltVertex

          public static byte[] saltVertex(byte[] ba)

      Salts a vertex ID represented as a byte array
      Parameters:
        `ba` - the vertex ID represented as a byte array
      Returns:
        a salted byte array

    - #### serializableToStr

          public static String serializableToStr(Serializable seri)
                                          throws IOException

      Convert from a Java Serializable object to a String encoding.
      Parameters:
        `seri` - an object of Serializable type. It must not be null.
      Throws:
        `IOException`

    - #### setBatchSize

          public void setBatchSize(int batchsize)

      Set the size of the batch used for update operations.
      Parameters:
        `batchsize` - the size of the batch used for update operations.

    - #### setCompression

          public void setCompression(String compress)

      Set the type of compression used in the property graph tables. This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the vertex/edge tables.
      Parameters:
        `compress` - the compression used in the property graph tables

    - #### setDataBlockEncoding

          public void setDataBlockEncoding(org.apache.hadoop.hbase.io.encoding.DataBlockEncoding dbe)

      Set the data block encoding used in the property graph tables. This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the vertex/edge tables.
      Parameters:
        `dbe` - the data block encoding used in the property graph tables

    - #### setDefaultEdgeOptFlag

          public void setDefaultEdgeOptFlag(OraclePropertyGraphBase.OptimizationFlag eof)

      Set the edge optimization flag associated to this property graph
      Parameters:
        `eof` - an OptimizationFlag object to be set to this property graph

    - #### setDefaultIndexParameters

          public void setDefaultIndexParameters(OracleIndexParameters indexParams)

      Set the default index parameters associated to this property graph. The indexParams provided here will be used when an automatic or manual index is to be created without an explicit specification of the index parameters.
      Specified by:
        `setDefaultIndexParameters` in class `OraclePropertyGraphBase`
      Parameters:
        `indexParams` - a `OracleIndexParameters` object.

    - #### setDefaultVertexOptFlag

          public void setDefaultVertexOptFlag(OraclePropertyGraphBase.OptimizationFlag vof)

      Set the default optimization flag for vertices associated to this property graph
      Parameters:
        `vof` - an OptimizationFlag object

    - #### setEdgeBlockCacheSize

          public void setEdgeBlockCacheSize(int blockCSize)

      Set the size of the block cache (in bytes) associated to the edge table This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the edge tables.
      Parameters:
        `blockCSize` - a positive integer representing the size of the block cache (in bytes) used in the vertex table. Default value set to 131072 bytes.

    - #### setEdgeFilterCallback

          public void setEdgeFilterCallback(EdgeFilterCallback efc)

      Set the default EdgeFilterCallback associated to this property graph
      Parameters:
        `efc` - a `EdgeFilterCallback` object to be set to this property graph

    - #### setEdgeInitialNumRegions

          public void setEdgeInitialNumRegions(int numRegions)

      Set the initial number of regions defined for the HBase edge tables associated to this property graph. Number of regions should be greater than 2. This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the edge tables.
      Parameters:
        `numRegions` - a positive integer with the initial number of regions for edge table. Default value set to 4

    - #### setEdgeSndIndexBlockCacheSize

          public void setEdgeSndIndexBlockCacheSize(int blockCSize)

      Set the size of the block cache (in bytes) associated to the edge secondary table This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the edge tables.
      Parameters:
        `blockCSize` - a positive integer representing the size of the block cache (in bytes) used in the vertex table. Default value set to 131072 bytes.

    - #### setEdgeSndIndexWriteBufferSize

          public void setEdgeSndIndexWriteBufferSize(long writebuffer)

      Set the size of the write buffer associated to the edge secondary index table
      Parameters:
        `writebuffer` - the size of the write buffer used in the edge secondary index table

    - #### setEdgeWriteBufferSize

          public void setEdgeWriteBufferSize(long writebuffer)

      Set the maximum size of the write buffer associated to the edge table
      Parameters:
        `writebuffer` - the maximum size of the write buffer used in the edge table

    - #### setIndexLuceneWriteBufferSize

          public void setIndexLuceneWriteBufferSize(long writebuffer)

      Set the maxium size of the write buffer associated to the Lucene index table
      Parameters:
        `writebuffer` - the maximum size of the write buffer used in the index table

    - #### setInitialNumRegions

          public void setInitialNumRegions(int numRegions)

      Set the initial number of regions defined for the HBase tables associated to this property graph. Number of regions should be greater than 1. This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the vertex/edge tables.
      Parameters:
        `numRegions` - the initial number of regions.

    - #### setLuceneBlockCacheSize

          public void setLuceneBlockCacheSize(int blockCSize)

      Set the size of the block cache (in bytes) associated to the Lucene index table This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the lucene tables.
      Parameters:
        `blockCSize` - a positive integer representing the size of the block cache (in bytes) used in the vertex table. Default value set to 131072 bytes.

    - #### setNumSplitsPerRegion

          public void setNumSplitsPerRegion(int iNumSplitsPerRegion)

      Set the number of splits per region to use when scanning vertices/edges
      Parameters:
        `iNumSplitsPerRegion` - a positive integer specifying the number of splits per region to use when scanning vertices/edges. Default value set to 1.

    - #### setProgressListener

          public void setProgressListener(ProgressListener pl)

      Sets the ProgressListener associated to this property graph.
      Parameters:
        `pl` - a ProgressListener object.

    - #### setQueueSize

          public void setQueueSize(int size)

      This method sets the queue size.
      Parameters:
        `size` - the size of the queue

    - #### setScanCachingSize

          public void setScanCachingSize(int iScanCachingSize)

      Set the caching size used in Scan operations
      Parameters:
        `iScanCachingSize` - the cache size to use.

    - #### setVertexBlockCacheSize

          public void setVertexBlockCacheSize(int blockCSize)

      Set the size of the block cache (in bytes) associated to the vertex table
      Parameters:
        `blockCSize` - a positive integer representing the size of the block cache (in bytes) used in the vertex table. This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the vertex tables. Default value set to 131072 bytes.

    - #### setVertexFilterCallback

          public void setVertexFilterCallback(VertexFilterCallback vfc)

      Set the default VertexFilterCallback associated to this property graph
      Parameters:
        `vfc` - a `VertexFilterCallback` object to be set to this property graph

    - #### setVertexInitialNumRegions

          public void setVertexInitialNumRegions(int numRegions)

      Set the initial number of regions defined for the HBase Vertex tables associated to this property graph. Number of regions should be greater than 2. This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the vertex tables.
      Parameters:
        `numRegions` - a positive integer with the initial number of regions for vertex table. Default value set to 4

    - #### setVertexSndIndexBlockCacheSize

          public void setVertexSndIndexBlockCacheSize(int blockCSize)

      Set the size of the block cache (in bytes) associated to the vertex secondary table This is a meta data operation, so changes to this setting will show after clearing the repository and recreating the vertex tables.
      Parameters:
        `blockCSize` - a positive integer representing the size of the block cache (in bytes) used in the vertex table. Default value set to 131072 bytes.

    - #### setVertexSndIndexWriteBufferSize

          public void setVertexSndIndexWriteBufferSize(long writebuffer)

      Set the maximum size of the write buffer associated to the vertex secondary index table
      Parameters:
        `writebuffer` - the maximum size of the write buffer used in the vertex secondary index table

    - #### setVertexWriteBufferSize

          public void setVertexWriteBufferSize(long writebuffer)

      Set the maximum size of the write buffer associated to the vertex table
      Parameters:
        `writebuffer` - the maximum size of the write buffer used in the vertex table

    - #### setWriteBufferSize

          public void setWriteBufferSize(long writebuffer)

      Set the maximum size of the write buffer associated to the graph tables
      Parameters:
        `writebuffer` - the maximum size of the write buffer used in the vertex table

    - #### shutdown

          public void shutdown()

      A shutdown function is required to properly close the graph.

    - #### startTransaction

          public void startTransaction()

      Start a transaction.

    - #### stopTransaction

          public void stopTransaction(TransactionalGraph.Conclusion conclusion)

      Stop the current transaction.

    - #### strToSerializable

          public static Object strToSerializable(String s)
                                          throws IOException

      Convert from a String encoding to a Serializable object
      Parameters:
        `s` - String representation of a Java Serializable object. It MUST not be null.
      Throws:
        `IOException`

    - #### toString

          public String toString()

      Returns a very succinct String representation of this Graph instance
      Overrides:
        `toString` in class `Object`

Copyright © 2015 Oracle and/or its affiliates. All Rights Reserved.